/*
 * XML Type:  oai_dcType
 * Namespace: http://www.openarchives.org/OAI/2.0/oai_dc/
 * Java type: org.openarchives.oai.x20.oaiDc.OaiDcType
 *
 * Automatically generated - do not modify.
 */
package uk.ljmu.oaibeans.oaidc;
/**
 * An XML oai_dcType(@http://www.openarchives.org/OAI/2.0/oai_dc/).
 *
 * This is a complex type.
 */
public class OaiDcTypeImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements uk.ljmu.oaibeans.oaidc.OaiDcType
{
    private static final long serialVersionUID = 1L;
    
    public OaiDcTypeImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName TITLE$0 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "title");
    private static final javax.xml.namespace.QName CREATOR$2 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "creator");
    private static final javax.xml.namespace.QName SUBJECT$4 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "subject");
    private static final javax.xml.namespace.QName DESCRIPTION$6 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "description");
    private static final javax.xml.namespace.QName PUBLISHER$8 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "publisher");
    private static final javax.xml.namespace.QName CONTRIBUTOR$10 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "contributor");
    private static final javax.xml.namespace.QName DATE$12 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "date");
    private static final javax.xml.namespace.QName TYPE$14 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "type");
    private static final javax.xml.namespace.QName FORMAT$16 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "format");
    private static final javax.xml.namespace.QName IDENTIFIER$18 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "identifier");
    private static final javax.xml.namespace.QName SOURCE$20 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "source");
    private static final javax.xml.namespace.QName LANGUAGE$22 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "language");
    private static final javax.xml.namespace.QName RELATION$24 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "relation");
    private static final javax.xml.namespace.QName COVERAGE$26 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "coverage");
    private static final javax.xml.namespace.QName RIGHTS$28 = 
        new javax.xml.namespace.QName("http://purl.org/dc/elements/1.1/", "rights");
    
    
    /**
     * Gets array of all "title" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getTitleArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(TITLE$0, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "title" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getTitleArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(TITLE$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "title" element
     */
    public int sizeOfTitleArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TITLE$0);
        }
    }
    
    /**
     * Sets array of all "title" element
     */
    public void setTitleArray(uk.ljmu.oaibeans.dcelements.ElementType[] titleArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(titleArray, TITLE$0);
        }
    }
    
    /**
     * Sets ith "title" element
     */
    public void setTitleArray(int i, uk.ljmu.oaibeans.dcelements.ElementType title)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(TITLE$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(title);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "title" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewTitle(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(TITLE$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "title" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewTitle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(TITLE$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "title" element
     */
    public void removeTitle(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TITLE$0, i);
        }
    }
    
    /**
     * Gets array of all "creator" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getCreatorArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CREATOR$2, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "creator" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getCreatorArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(CREATOR$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "creator" element
     */
    public int sizeOfCreatorArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CREATOR$2);
        }
    }
    
    /**
     * Sets array of all "creator" element
     */
    public void setCreatorArray(uk.ljmu.oaibeans.dcelements.ElementType[] creatorArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(creatorArray, CREATOR$2);
        }
    }
    
    /**
     * Sets ith "creator" element
     */
    public void setCreatorArray(int i, uk.ljmu.oaibeans.dcelements.ElementType creator)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(CREATOR$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(creator);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "creator" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewCreator(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(CREATOR$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "creator" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewCreator()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(CREATOR$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "creator" element
     */
    public void removeCreator(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CREATOR$2, i);
        }
    }
    
    /**
     * Gets array of all "subject" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getSubjectArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SUBJECT$4, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "subject" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getSubjectArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(SUBJECT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "subject" element
     */
    public int sizeOfSubjectArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUBJECT$4);
        }
    }
    
    /**
     * Sets array of all "subject" element
     */
    public void setSubjectArray(uk.ljmu.oaibeans.dcelements.ElementType[] subjectArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(subjectArray, SUBJECT$4);
        }
    }
    
    /**
     * Sets ith "subject" element
     */
    public void setSubjectArray(int i, uk.ljmu.oaibeans.dcelements.ElementType subject)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(SUBJECT$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(subject);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "subject" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewSubject(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(SUBJECT$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "subject" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewSubject()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(SUBJECT$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "subject" element
     */
    public void removeSubject(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUBJECT$4, i);
        }
    }
    
    /**
     * Gets array of all "description" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getDescriptionArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(DESCRIPTION$6, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "description" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getDescriptionArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(DESCRIPTION$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "description" element
     */
    public int sizeOfDescriptionArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DESCRIPTION$6);
        }
    }
    
    /**
     * Sets array of all "description" element
     */
    public void setDescriptionArray(uk.ljmu.oaibeans.dcelements.ElementType[] descriptionArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(descriptionArray, DESCRIPTION$6);
        }
    }
    
    /**
     * Sets ith "description" element
     */
    public void setDescriptionArray(int i, uk.ljmu.oaibeans.dcelements.ElementType description)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(DESCRIPTION$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(description);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "description" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewDescription(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(DESCRIPTION$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "description" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewDescription()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(DESCRIPTION$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "description" element
     */
    public void removeDescription(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DESCRIPTION$6, i);
        }
    }
    
    /**
     * Gets array of all "publisher" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getPublisherArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PUBLISHER$8, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "publisher" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getPublisherArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(PUBLISHER$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "publisher" element
     */
    public int sizeOfPublisherArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PUBLISHER$8);
        }
    }
    
    /**
     * Sets array of all "publisher" element
     */
    public void setPublisherArray(uk.ljmu.oaibeans.dcelements.ElementType[] publisherArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(publisherArray, PUBLISHER$8);
        }
    }
    
    /**
     * Sets ith "publisher" element
     */
    public void setPublisherArray(int i, uk.ljmu.oaibeans.dcelements.ElementType publisher)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(PUBLISHER$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(publisher);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "publisher" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewPublisher(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(PUBLISHER$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "publisher" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewPublisher()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(PUBLISHER$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "publisher" element
     */
    public void removePublisher(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PUBLISHER$8, i);
        }
    }
    
    /**
     * Gets array of all "contributor" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getContributorArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(CONTRIBUTOR$10, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "contributor" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getContributorArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(CONTRIBUTOR$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "contributor" element
     */
    public int sizeOfContributorArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONTRIBUTOR$10);
        }
    }
    
    /**
     * Sets array of all "contributor" element
     */
    public void setContributorArray(uk.ljmu.oaibeans.dcelements.ElementType[] contributorArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(contributorArray, CONTRIBUTOR$10);
        }
    }
    
    /**
     * Sets ith "contributor" element
     */
    public void setContributorArray(int i, uk.ljmu.oaibeans.dcelements.ElementType contributor)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(CONTRIBUTOR$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(contributor);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "contributor" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewContributor(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(CONTRIBUTOR$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "contributor" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewContributor()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(CONTRIBUTOR$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "contributor" element
     */
    public void removeContributor(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONTRIBUTOR$10, i);
        }
    }
    
    /**
     * Gets array of all "date" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getDateArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(DATE$12, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "date" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getDateArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(DATE$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "date" element
     */
    public int sizeOfDateArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DATE$12);
        }
    }
    
    /**
     * Sets array of all "date" element
     */
    public void setDateArray(uk.ljmu.oaibeans.dcelements.ElementType[] dateArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(dateArray, DATE$12);
        }
    }
    
    /**
     * Sets ith "date" element
     */
    public void setDateArray(int i, uk.ljmu.oaibeans.dcelements.ElementType date)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(DATE$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(date);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "date" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewDate(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(DATE$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "date" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewDate()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(DATE$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "date" element
     */
    public void removeDate(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DATE$12, i);
        }
    }
    
    /**
     * Gets array of all "type" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getTypeArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(TYPE$14, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "type" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getTypeArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(TYPE$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "type" element
     */
    public int sizeOfTypeArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TYPE$14);
        }
    }
    
    /**
     * Sets array of all "type" element
     */
    public void setTypeArray(uk.ljmu.oaibeans.dcelements.ElementType[] typeArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(typeArray, TYPE$14);
        }
    }
    
    /**
     * Sets ith "type" element
     */
    public void setTypeArray(int i, uk.ljmu.oaibeans.dcelements.ElementType type)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(TYPE$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(type);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "type" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewType(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(TYPE$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "type" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewType()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(TYPE$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "type" element
     */
    public void removeType(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TYPE$14, i);
        }
    }
    
    /**
     * Gets array of all "format" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getFormatArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(FORMAT$16, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "format" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getFormatArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(FORMAT$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "format" element
     */
    public int sizeOfFormatArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FORMAT$16);
        }
    }
    
    /**
     * Sets array of all "format" element
     */
    public void setFormatArray(uk.ljmu.oaibeans.dcelements.ElementType[] formatArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(formatArray, FORMAT$16);
        }
    }
    
    /**
     * Sets ith "format" element
     */
    public void setFormatArray(int i, uk.ljmu.oaibeans.dcelements.ElementType format)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(FORMAT$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(format);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "format" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewFormat(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(FORMAT$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "format" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewFormat()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(FORMAT$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "format" element
     */
    public void removeFormat(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FORMAT$16, i);
        }
    }
    
    /**
     * Gets array of all "identifier" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getIdentifierArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(IDENTIFIER$18, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "identifier" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getIdentifierArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(IDENTIFIER$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "identifier" element
     */
    public int sizeOfIdentifierArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(IDENTIFIER$18);
        }
    }
    
    /**
     * Sets array of all "identifier" element
     */
    public void setIdentifierArray(uk.ljmu.oaibeans.dcelements.ElementType[] identifierArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(identifierArray, IDENTIFIER$18);
        }
    }
    
    /**
     * Sets ith "identifier" element
     */
    public void setIdentifierArray(int i, uk.ljmu.oaibeans.dcelements.ElementType identifier)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(IDENTIFIER$18, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(identifier);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "identifier" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewIdentifier(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(IDENTIFIER$18, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "identifier" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewIdentifier()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(IDENTIFIER$18);
            return target;
        }
    }
    
    /**
     * Removes the ith "identifier" element
     */
    public void removeIdentifier(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(IDENTIFIER$18, i);
        }
    }
    
    /**
     * Gets array of all "source" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getSourceArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(SOURCE$20, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "source" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getSourceArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(SOURCE$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "source" element
     */
    public int sizeOfSourceArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SOURCE$20);
        }
    }
    
    /**
     * Sets array of all "source" element
     */
    public void setSourceArray(uk.ljmu.oaibeans.dcelements.ElementType[] sourceArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(sourceArray, SOURCE$20);
        }
    }
    
    /**
     * Sets ith "source" element
     */
    public void setSourceArray(int i, uk.ljmu.oaibeans.dcelements.ElementType source)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(SOURCE$20, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(source);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "source" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewSource(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(SOURCE$20, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "source" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewSource()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(SOURCE$20);
            return target;
        }
    }
    
    /**
     * Removes the ith "source" element
     */
    public void removeSource(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SOURCE$20, i);
        }
    }
    
    /**
     * Gets array of all "language" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getLanguageArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(LANGUAGE$22, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "language" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getLanguageArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(LANGUAGE$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "language" element
     */
    public int sizeOfLanguageArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LANGUAGE$22);
        }
    }
    
    /**
     * Sets array of all "language" element
     */
    public void setLanguageArray(uk.ljmu.oaibeans.dcelements.ElementType[] languageArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(languageArray, LANGUAGE$22);
        }
    }
    
    /**
     * Sets ith "language" element
     */
    public void setLanguageArray(int i, uk.ljmu.oaibeans.dcelements.ElementType language)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(LANGUAGE$22, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(language);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "language" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewLanguage(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(LANGUAGE$22, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "language" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewLanguage()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(LANGUAGE$22);
            return target;
        }
    }
    
    /**
     * Removes the ith "language" element
     */
    public void removeLanguage(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LANGUAGE$22, i);
        }
    }
    
    /**
     * Gets array of all "relation" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getRelationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RELATION$24, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "relation" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getRelationArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(RELATION$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "relation" element
     */
    public int sizeOfRelationArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RELATION$24);
        }
    }
    
    /**
     * Sets array of all "relation" element
     */
    public void setRelationArray(uk.ljmu.oaibeans.dcelements.ElementType[] relationArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(relationArray, RELATION$24);
        }
    }
    
    /**
     * Sets ith "relation" element
     */
    public void setRelationArray(int i, uk.ljmu.oaibeans.dcelements.ElementType relation)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(RELATION$24, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(relation);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "relation" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewRelation(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(RELATION$24, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "relation" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewRelation()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(RELATION$24);
            return target;
        }
    }
    
    /**
     * Removes the ith "relation" element
     */
    public void removeRelation(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RELATION$24, i);
        }
    }
    
    /**
     * Gets array of all "coverage" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getCoverageArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(COVERAGE$26, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "coverage" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getCoverageArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(COVERAGE$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "coverage" element
     */
    public int sizeOfCoverageArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COVERAGE$26);
        }
    }
    
    /**
     * Sets array of all "coverage" element
     */
    public void setCoverageArray(uk.ljmu.oaibeans.dcelements.ElementType[] coverageArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(coverageArray, COVERAGE$26);
        }
    }
    
    /**
     * Sets ith "coverage" element
     */
    public void setCoverageArray(int i, uk.ljmu.oaibeans.dcelements.ElementType coverage)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(COVERAGE$26, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(coverage);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "coverage" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewCoverage(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(COVERAGE$26, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "coverage" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewCoverage()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(COVERAGE$26);
            return target;
        }
    }
    
    /**
     * Removes the ith "coverage" element
     */
    public void removeCoverage(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COVERAGE$26, i);
        }
    }
    
    /**
     * Gets array of all "rights" elements
     */
    @SuppressWarnings("unchecked")
	public uk.ljmu.oaibeans.dcelements.ElementType[] getRightsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RIGHTS$28, targetList);
            uk.ljmu.oaibeans.dcelements.ElementType[] result = new uk.ljmu.oaibeans.dcelements.ElementType[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "rights" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType getRightsArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(RIGHTS$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "rights" element
     */
    public int sizeOfRightsArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RIGHTS$28);
        }
    }
    
    /**
     * Sets array of all "rights" element
     */
    public void setRightsArray(uk.ljmu.oaibeans.dcelements.ElementType[] rightsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(rightsArray, RIGHTS$28);
        }
    }
    
    /**
     * Sets ith "rights" element
     */
    public void setRightsArray(int i, uk.ljmu.oaibeans.dcelements.ElementType rights)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().find_element_user(RIGHTS$28, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(rights);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "rights" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType insertNewRights(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().insert_element_user(RIGHTS$28, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "rights" element
     */
    public uk.ljmu.oaibeans.dcelements.ElementType addNewRights()
    {
        synchronized (monitor())
        {
            check_orphaned();
            uk.ljmu.oaibeans.dcelements.ElementType target = null;
            target = (uk.ljmu.oaibeans.dcelements.ElementType)get_store().add_element_user(RIGHTS$28);
            return target;
        }
    }
    
    /**
     * Removes the ith "rights" element
     */
    public void removeRights(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RIGHTS$28, i);
        }
    }
}
